System.Span<T> yapısı
Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.
Türü Span<T> , yönetilen yığın yerine yığında ayrılan bir başvuru yapısıdır . Başvuru yapısı türleri, yönetilen yığına yükseltilemeyeceklerinden emin olmak için bir dizi kısıtlamaya sahiptir; bunlar kutulanamaz, türündeki Objectdynamic değişkenlere veya herhangi bir arabirim türüne atanamaz, başvuru türünde alanlar olamaz ve ve sınırlar arasında awaityield kullanılamazlar. Buna ek olarak, iki yönteme çağrır Equals(Object) ve GetHashCodebir NotSupportedExceptionoluşturur.
Önemli
Yalnızca yığın türünde olduğundan, Span<T> yığındaki arabelleklere yönelik başvuruların depolanmasını gerektiren birçok senaryo için uygun değildir. Bu, örneğin zaman uyumsuz yöntem çağrıları yapılan yordamlar için geçerlidir. Bu tür senaryolar için tamamlayıcı System.Memory<T> ve System.ReadOnlyMemory<T> türleri kullanabilirsiniz.
Sabit veya salt okunur yapıları temsil eden yayılma alanları için kullanın System.ReadOnlySpan<T>.
Bellek
A Span<T> , rastgele belleğin bitişik bir bölgesini temsil eder. Bir Span<T> örnek genellikle bir dizinin öğelerini veya dizinin bir bölümünü tutmak için kullanılır. Ancak bir diziden farklı olarak, bir Span<T> örnek yönetilen belleğe, yerel belleğe veya yığında yönetilen belleğe işaret edebilir. Aşağıdaki örnek bir diziden bir Span<Byte> oluşturur:
// Create a span over an array.
var array = new byte[100];
var arraySpan = new Span<byte>(array);
byte data = 0;
for (int ctr = 0; ctr < arraySpan.Length; ctr++)
arraySpan[ctr] = data++;
int arraySum = 0;
foreach (var value in array)
arraySum += value;
Console.WriteLine($"The sum is {arraySum}");
// Output: The sum is 4950
// Create a span over an array.
let array = Array.zeroCreate<byte> 100
let arraySpan = Span<byte> array
let mutable data = 0uy
for i = 0 to arraySpan.Length - 1 do
arraySpan[i] <- data
data <- data + 1uy
let mutable arraySum = 0
for value in array do
arraySum <- arraySum + int value
printfn $"The sum is {arraySum}"
// Output: The sum is 4950
Aşağıdaki örnek 100 bayttan yerel bellek oluşturur Span<Byte> :
// Create a span from native memory.
var native = Marshal.AllocHGlobal(100);
Span<byte> nativeSpan;
unsafe
{
nativeSpan = new Span<byte>(native.ToPointer(), 100);
}
byte data = 0;
for (int ctr = 0; ctr < nativeSpan.Length; ctr++)
nativeSpan[ctr] = data++;
int nativeSum = 0;
foreach (var value in nativeSpan)
nativeSum += value;
Console.WriteLine($"The sum is {nativeSum}");
Marshal.FreeHGlobal(native);
// Output: The sum is 4950
// Create a span from native memory.
let native = Marshal.AllocHGlobal 100
let nativeSpan = Span<byte>(native.ToPointer(), 100)
let mutable data = 0uy
for i = 0 to nativeSpan.Length - 1 do
nativeSpan[i] <- data
data <- data + 1uy
let mutable nativeSum = 0
for value in nativeSpan do
nativeSum <- nativeSum + int value
printfn $"The sum is {nativeSum}"
Marshal.FreeHGlobal native
// Output: The sum is 4950
Aşağıdaki örnek, yığında 100 bayt bellek ayırmak için C# stackalloc anahtar sözcüğünü kullanır:
// Create a span on the stack.
byte data = 0;
Span<byte> stackSpan = stackalloc byte[100];
for (int ctr = 0; ctr < stackSpan.Length; ctr++)
stackSpan[ctr] = data++;
int stackSum = 0;
foreach (var value in stackSpan)
stackSum += value;
Console.WriteLine($"The sum is {stackSum}");
// Output: The sum is 4950
// Create a span on the stack.
let mutable data = 0uy
let stackSpan =
let p = NativeInterop.NativePtr.stackalloc<byte> 100 |> NativeInterop.NativePtr.toVoidPtr
Span<byte>(p, 100)
for i = 0 to stackSpan.Length - 1 do
stackSpan[i] <- data
data <- data + 1uy
let mutable stackSum = 0
for value in stackSpan do
stackSum <- stackSum + int value
printfn $"The sum is {stackSum}"
// Output: The sum is 4950
Span<T> Rastgele bir bellek bloğu üzerinde soyutlama olduğundan, türün Span<T> yöntemleri ve parametreleri olan Span<T> yöntemler, kapsüllediği bellek türünden bağımsız olarak herhangi bir Span<T> nesne üzerinde çalışır. Örneğin, aşağıdaki örnekte gösterildiği gibi, kodun yayılma alanını başlatan ve öğelerinin toplamını hesaplayan ayrı bölümlerinin her biri tek başlatma ve hesaplama yöntemlerine dönüştürülebilir:
public static void WorkWithSpans()
{
// Create a span over an array.
var array = new byte[100];
var arraySpan = new Span<byte>(array);
InitializeSpan(arraySpan);
Console.WriteLine($"The sum is {ComputeSum(arraySpan):N0}");
// Create an array from native memory.
var native = Marshal.AllocHGlobal(100);
Span<byte> nativeSpan;
unsafe
{
nativeSpan = new Span<byte>(native.ToPointer(), 100);
}
InitializeSpan(nativeSpan);
Console.WriteLine($"The sum is {ComputeSum(nativeSpan):N0}");
Marshal.FreeHGlobal(native);
// Create a span on the stack.
Span<byte> stackSpan = stackalloc byte[100];
InitializeSpan(stackSpan);
Console.WriteLine($"The sum is {ComputeSum(stackSpan):N0}");
}
public static void InitializeSpan(Span<byte> span)
{
byte value = 0;
for (int ctr = 0; ctr < span.Length; ctr++)
span[ctr] = value++;
}
public static int ComputeSum(Span<byte> span)
{
int sum = 0;
foreach (var value in span)
sum += value;
return sum;
}
// The example displays the following output:
// The sum is 4,950
// The sum is 4,950
// The sum is 4,950
open System
open System.Runtime.InteropServices
open FSharp.NativeInterop
// Package FSharp.NativeInterop.NativePtr.stackalloc for reuse.
let inline stackalloc<'a when 'a: unmanaged> length : Span<'a> =
let voidPointer = NativePtr.stackalloc<'a> length |> NativePtr.toVoidPtr
Span<'a>(voidPointer, length)
let initializeSpan (span: Span<byte>) =
let mutable value = 0uy
for i = 0 to span.Length - 1 do
span[i] <- value
value <- value + 1uy
let computeSum (span: Span<byte>) =
let mutable sum = 0
for value in span do
sum <- sum + int value
sum
let workWithSpans () =
// Create a span over an array.
let array = Array.zeroCreate<byte> 100
let arraySpan = Span<byte> array
initializeSpan arraySpan
printfn $"The sum is {computeSum arraySpan:N0}"
// Create an array from native memory.
let native = Marshal.AllocHGlobal 100
let nativeSpan = Span<byte>(native.ToPointer(), 100)
initializeSpan nativeSpan
printfn $"The sum is {computeSum nativeSpan:N0}"
Marshal.FreeHGlobal native
// Create a span on the stack.
let stackSpan = stackalloc 100
initializeSpan stackSpan
printfn $"The sum is {computeSum stackSpan:N0}"
// The example displays the following output:
// The sum is 4,950
// The sum is 4,950
// The sum is 4,950
Diziler
Bir diziyi sarmaladığında, Span<T> Bellek bölümündeki örneklerde olduğu gibi dizinin tamamını sarmalayabilir. Dilimlemeye destek olduğundan, Span<T> dizideki herhangi bir bitişik aralığa da işaret edebilir.
Aşağıdaki örnek, 10 öğeli bir tamsayı dizisinin orta beş öğesinin bir dilimini oluşturur. Kodun, dilimdeki her tamsayının değerlerini ikiye katladığını unutmayın. Çıktıda gösterildiği gibi, span tarafından yapılan değişiklikler dizinin değerlerine yansıtılır.
using System;
var array = new int[] { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
var slice = new Span<int>(array, 2, 5);
for (int ctr = 0; ctr < slice.Length; ctr++)
slice[ctr] *= 2;
// Examine the original array values.
foreach (var value in array)
Console.Write($"{value} ");
Console.WriteLine();
// The example displays the following output:
// 2 4 12 16 20 24 28 16 18 20
module Program
open System
[<EntryPoint>]
let main _ =
let array = [| 2; 4; 6; 8; 10; 12; 14; 16; 18; 20 |]
let slice = Span<int>(array, 2, 5)
for i = 0 to slice.Length - 1 do
slice[i] <- slice[i] * 2
// Examine the original array values.
for value in array do
printf $"{value} "
printfn ""
0
// The example displays the following output:
// 2 4 12 16 20 24 28 16 18 20
Dilimler
Span<T> , belirtilen dizinde Slice başlayan geçerli yayılma alanının dışında bir dilim oluşturan yöntemin iki aşırı yüklemesini içerir. Bu, bir Span<T> veri işleme işlem hattının bölümleri tarafından gerektiğinde işlenebilen mantıksal öbekler kümesindeki verileri en düşük performans etkisiyle işlemeyi mümkün kılar. Örneğin, modern sunucu protokolleri genellikle metin tabanlı olduğundan, dizelerin ve alt dizelerin değiştirilmesi özellikle önemlidir. String sınıfında, alt dizeleri ayıklamak için ana yöntem şeklindedirSubstring. Kapsamlı dize işlemeye dayanan veri işlem hatları için kullanımı aşağıdakilerden dolayı bazı performans cezaları sunar:
- Alt dizeyi tutmak için yeni bir dize oluşturur.
- Özgün dizedeki karakterlerin bir alt kümesini yeni dizeye kopyalar.
Bu ayırma ve kopyalama işlemi, aşağıdaki örnekte gösterildiği gibi veya ReadOnlySpan<T>kullanılarak Span<T> ortadan kaldırılabilir:
using System;
class Program2
{
static void Run()
{
string contentLength = "Content-Length: 132";
var length = GetContentLength(contentLength.ToCharArray());
Console.WriteLine($"Content length: {length}");
}
private static int GetContentLength(ReadOnlySpan<char> span)
{
var slice = span.Slice(16);
return int.Parse(slice);
}
}
// Output:
// Content length: 132
module Program2
open System
let getContentLength (span: ReadOnlySpan<char>) =
let slice = span.Slice 16
Int32.Parse slice
let contentLength = "Content-Length: 132"
let length = getContentLength (contentLength.ToCharArray())
printfn $"Content length: {length}"
// Output:
// Content length: 132
Geri Bildirim
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz. https://aka.ms/ContentUserFeedback.
Gönderin ve geri bildirimi görüntüleyin